import { useState, useCallback, useEffect, useRef } from 'react';
import { SessionService } from '../services/sessionService';

// localStorage keys
const CURRENT_SESSION_KEY = 'current-session-id';
const NEWLY_CREATED_SESSIONS_KEY = 'newly-created-sessions';

// 从 localStorage 读取新会话集合
const loadNewlyCreatedSessions = () => {
    try {
        const stored = localStorage.getItem(NEWLY_CREATED_SESSIONS_KEY);
        if (stored) {
            const sessionIds = JSON.parse(stored);
            console.log('📂 从localStorage加载新会话标记:', sessionIds);
            return new Set(sessionIds);
        }
    } catch (error) {
        console.warn('Failed to load newly created sessions from localStorage:', error);
    }
    return new Set();
};

// 保存新会话集合到 localStorage
const saveNewlyCreatedSessions = (sessionsSet) => {
    try {
        const sessionIds = Array.from(sessionsSet);
        localStorage.setItem(NEWLY_CREATED_SESSIONS_KEY, JSON.stringify(sessionIds));
        console.log('💾 保存新会话标记到localStorage:', sessionIds);
    } catch (error) {
        console.warn('Failed to save newly created sessions to localStorage:', error);
    }
};

export const useSession = () => {
    const [currentSessionId, setCurrentSessionId] = useState(() => {
        // 初始化时从localStorage读取
        try {
            return localStorage.getItem(CURRENT_SESSION_KEY) || null;
        } catch (error) {
            console.warn('Failed to read session from localStorage:', error);
            return null;
        }
    });
    const [sessions, setSessions] = useState([]);
    const [isLoadingSessions, setIsLoadingSessions] = useState(false);
    const [isCreatingSession, setIsCreatingSession] = useState(false);
    const [newlyCreatedSessions, setNewlyCreatedSessions] = useState(() => loadNewlyCreatedSessions());
    // 使用 ref 立即标记新会话，避免异步状态更新导致的问题
    const newlyCreatedSessionsRef = useRef(loadNewlyCreatedSessions());

    // 辅助函数：更新当前会话ID并保存到localStorage
    const updateCurrentSessionId = useCallback((sessionId) => {
        setCurrentSessionId(sessionId);
        try {
            if (sessionId) {
                localStorage.setItem(CURRENT_SESSION_KEY, sessionId);
            } else {
                localStorage.removeItem(CURRENT_SESSION_KEY);
            }
        } catch (error) {
            console.warn('Failed to save session to localStorage:', error);
        }
    }, []);

    // 加载会话列表
    const loadSessions = useCallback(async () => {
        setIsLoadingSessions(true);
        try {
            const sessionList = await SessionService.getSessions(0);
            setSessions(sessionList);
            return sessionList;
        } catch (error) {
            console.error('加载会话列表失败:', error);
            // 对于网络错误，返回空数组但不阻止后续操作
            if (error.message.includes('网络连接失败')) {
                setSessions([]);
                return [];
            }
            return [];
        } finally {
            setIsLoadingSessions(false);
        }
    }, []);

    // 创建新会话
    const createNewSession = useCallback(async () => {
        setIsCreatingSession(true);
        try {
            const sessionId = await SessionService.createSession();
            
            // 立即使用ref标记新会话（同步操作）
            newlyCreatedSessionsRef.current.add(sessionId);
            console.log('✅ 立即标记新会话:', sessionId, '当前新会话集合:', Array.from(newlyCreatedSessionsRef.current));
            
            // 保存到 localStorage（持久化）
            saveNewlyCreatedSessions(newlyCreatedSessionsRef.current);
            
            // 同时更新状态（用于UI）
            setNewlyCreatedSessions(prev => new Set([...prev, sessionId]));
            
            // 更新当前会话ID
            updateCurrentSessionId(sessionId);

            // 刷新会话列表
            await loadSessions();

            console.log('新会话创建成功，ID:', sessionId);
            return sessionId;
        } catch (error) {
            console.error('创建新会话失败:', error);
            throw error;
        } finally {
            setIsCreatingSession(false);
        }
    }, [loadSessions, updateCurrentSessionId]);

    // 检查会话是否是新创建的（使用ref确保立即获取最新值）
    const isNewlyCreatedSession = useCallback((sessionId) => {
        const isNew = newlyCreatedSessionsRef.current.has(sessionId);
        console.log('🔍 检查会话:', sessionId, '是否为新会话:', isNew, '新会话集合:', Array.from(newlyCreatedSessionsRef.current));
        return isNew;
    }, []);

    // 标记会话已有消息（不再是新会话）
    const markSessionAsUsed = useCallback((sessionId) => {
        // 同时更新 ref 和 state
        newlyCreatedSessionsRef.current.delete(sessionId);
        console.log('✓ 标记会话已使用:', sessionId, '剩余新会话:', Array.from(newlyCreatedSessionsRef.current));
        
        // 保存到 localStorage（持久化）
        saveNewlyCreatedSessions(newlyCreatedSessionsRef.current);
        
        setNewlyCreatedSessions(prev => {
            const newSet = new Set(prev);
            newSet.delete(sessionId);
            return newSet;
        });
    }, []);

    // 切换会话
    const switchSession = useCallback((sessionId, shouldLoadHistory = false) => {
        updateCurrentSessionId(sessionId);
        // 返回是否应该加载历史记录的标志
        return { sessionId, shouldLoadHistory };
    }, [updateCurrentSessionId]);

    // 删除会话
    const deleteSession = useCallback(async (sessionId) => {
        try {
            await SessionService.deleteSession(sessionId);

            // 从新会话集合中移除（如果存在）
            if (newlyCreatedSessionsRef.current.has(sessionId)) {
                newlyCreatedSessionsRef.current.delete(sessionId);
                saveNewlyCreatedSessions(newlyCreatedSessionsRef.current);
                setNewlyCreatedSessions(prev => {
                    const newSet = new Set(prev);
                    newSet.delete(sessionId);
                    return newSet;
                });
                console.log('🗑️ 删除会话时清理新会话标记:', sessionId);
            }

            // 如果删除的是当前会话，需要智能切换到其他会话
            if (sessionId === currentSessionId) {
                // 找到要删除的会话在列表中的索引
                const currentIndex = sessions.findIndex(s => s.id === sessionId);
                
                // 过滤掉要删除的会话，获取剩余会话
                const remainingSessions = sessions.filter(s => s.id !== sessionId);
                
                if (remainingSessions.length > 0) {
                    // 如果还有其他会话，智能选择下一个会话
                    let nextSession;
                    
                    if (currentIndex < remainingSessions.length) {
                        // 如果删除的不是最后一个，选择下一个会话
                        nextSession = remainingSessions[currentIndex];
                    } else {
                        // 如果删除的是最后一个，选择前一个会话
                        nextSession = remainingSessions[remainingSessions.length - 1];
                    }
                    
                    // 切换到选定的会话
                    updateCurrentSessionId(nextSession.id);
                } else {
                    // 如果没有其他会话了，创建新会话
                    await createNewSession();
                }
            }

            // 刷新会话列表
            await loadSessions();
        } catch (error) {
            console.error('删除会话失败:', error);
            throw error;
        }
    }, [currentSessionId, sessions, createNewSession, loadSessions, updateCurrentSessionId]);

    // 复制会话
    const copySession = useCallback(async (sessionId) => {
        try {
            const newSessionId = await SessionService.copySession(sessionId);

            // 刷新会话列表
            await loadSessions();

            return newSessionId;
        } catch (error) {
            console.error('复制会话失败:', error);
            throw error;
        }
    }, [loadSessions]);

    // 更新会话标题
    const updateSessionTitle = useCallback(async (sessionId, newTitle) => {
        try {
            const session = sessions.find(s => s.id === sessionId);
            if (!session) return;

            await SessionService.updateSession(sessionId, newTitle, session);

            // 刷新会话列表
            await loadSessions();
        } catch (error) {
            console.error('更新会话标题失败:', error);
            throw error;
        }
    }, [sessions, loadSessions]);

    // 组件加载时初始化（避免严格模式重复执行）
    const hasInitializedRef = useRef(false);
    useEffect(() => {
        if (hasInitializedRef.current) return;
        hasInitializedRef.current = true;

        (async () => {
            const list = await loadSessions();
            if (list && list.length > 0) {
                // 清理不存在的新会话标记（会话已被删除）
                const existingSessionIds = new Set(list.map(s => s.id));
                let needsCleanup = false;
                
                newlyCreatedSessionsRef.current.forEach(sessionId => {
                    if (!existingSessionIds.has(sessionId)) {
                        newlyCreatedSessionsRef.current.delete(sessionId);
                        needsCleanup = true;
                        console.log('🧹 清理不存在的新会话标记:', sessionId);
                    }
                });
                
                if (needsCleanup) {
                    saveNewlyCreatedSessions(newlyCreatedSessionsRef.current);
                    setNewlyCreatedSessions(new Set(newlyCreatedSessionsRef.current));
                }
                
                // 检查localStorage中保存的会话ID是否仍然存在
                if (currentSessionId) {
                    const sessionExists = list.some(session => session.id === currentSessionId);
                    if (!sessionExists) {
                        // 如果保存的会话不存在了，选择第一个会话
                        updateCurrentSessionId(list[0].id);
                    }
                    // 如果会话存在，保持当前选择
                } else {
                    // 如果没有保存的会话ID，默认选中最新一个
                    updateCurrentSessionId(list[0].id);
                }
            } else {
                // 列表为空时创建一个新会话
                await createNewSession();
            }
        })();
    }, [loadSessions, createNewSession, currentSessionId, updateCurrentSessionId]);

    return {
        currentSessionId,
        sessions,
        isLoadingSessions,
        isCreatingSession,
        createNewSession,
        switchSession,
        deleteSession,
        copySession,
        updateSessionTitle,
        loadSessions,
        isNewlyCreatedSession,
        markSessionAsUsed,
    };
};